package com.yibo.redis.util;

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.ZSetOperations;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * redis命令
 *
 * @author zhanglei
 */
public interface RedisCommand<K,V> {

    /**
     * 获取redis中所有的键值
     *
     * 对应redis命令 keys  *
     *
     * @return  set键集合
     */
    Set<K>  getAllKeys();


    /**
     * 模糊查询key 键集合
     *
     * 对应redis命令  keys *pattern*
     *
     * @param pattern  模糊条件
     * @return     键集合
     */
    Set<K>  getKeysPattern(String  pattern);


    /**
     * 获取所有的字符串键值
     *
     * @return  k,v键值对
     */
    Map<K,V>  getAllString();


    /**
     * 获取所有的集合set  键值
     *
     * @return  k  set  键值对
     */
    Map<K,Set<V>>  getAllSet();


    /**
     * 获取所有的正序集合  不获取分值，即权重值
     * @return   k  set有序集合 正序
     */
    Map<K,Set<V>>  getAllZSetRange();


    /**
     * 获取所有的集合  倒序 不获取分值
     * @return  k set有序集合  倒序
     */
    Map<K,Set<V>>  getAllZSetReverseRange();


    /**
     * 获取所有的list列表   key-value
     * @return  k  list
     */
    Map<K,List<V>> getAllList();


    /**
     * 获取所有的hash表
     *
     * @return  k hash表
     */
    Map<K,Map<K,V>> getAllMap();



    /**
     * 添加一个list列表
     *
     * @param key          键
     * @param objectList   list列表
     */
    void  addList(K key,List<V> objectList);


    /**
     * 向list列表中添加一个值
     *
     * @param key    列表键
     * @param value  值
     * @return       返回添加列表中的下标
     */
    long  addList(K key , V value);

    /**
     * 向list列表中添加值
     *
     * @param key  键
     * @param obj  值  可变参数
     * @return     list下标
     */
    long addList(K key , V ...obj);

    /**
     * 获取list列表中的值
     *
     * @param key    列表键
     * @param start  开始下标
     * @param end    结束下标
     * @return       列表
     */
    List<V> getList(K key , long start , long end);


    /**
     * 获取指定列表
     *
     * @param key  列表键
     * @return     列表
     */
    List<V>  getList(K key);

    /**
     * 获取指定列表的数量
     *
     * @param key  列表键
     * @return     数量
     */
    long  getListSize(K key);


    /**
     * 移除list列表中某个值  list列表可以存在重复值，所以移除的值可能是多个
     *
     * @param key   列表键
     * @param value  值
     * @return       移除的数量
     */
    long removeListValue(K key , V value);

    /**
     * 移除list中多个值
     *
     * @param key    list键
     * @param value  值  可变参数
     * @return    移除数量
     */
    long removeListValue(K key , V... value);


    /**
     * 从左向右插入  list列表
     *
     * @param key    list键
     * @param value  value值  可变参数
     */
    void  addListLeft(K key,V... value);


    /**
     * 从右向左插入 list列表
     *
     * @param key   键
     * @param value 值
     */
    void  addListRight(K key,V... value);


    /**
     * 批量删除key对应的value
     *
     * @param keys  键
     */
    void  remove(final K... keys);

    /**
     * 删除指定的键对应的值
     * 精确删除
     *
     * @param key  键
     */
    void  remove(final K key);


    /**
     * 通过权重分数区间删除指定的有序集合值
     *
     * @param key   键值
     * @param start  索引开始位置
     * @param end    索引结束位置
     */
    void  removeZSetRangeByScore(K key , double start , double end);


    /**
     * 设置指定set的过期时间
     *
     * @param key   键
     * @param time  值
     * @return  设置结果
     */
    Boolean  setSetExpireTime(K key, Long time);


    /**
     * 设置有序集合的过期时间
     *
     * @param key  键
     * @param time  过期时间
     * @return      设置结果
     */
    Boolean  setZSetExpireTime(K key, Long time);


    /**
     * 判断数据库中键是否存在
     *
     * @param key  键
     * @return   boolean
     */
    boolean exists(final K key);


    /**
     * 获取指定的缓存值
     *
     * @param key   键
     * @return   结果  可是对象
     */
    V  get(final K key);

    /**
     * 自动获取指定对象值  可以是string  hash  list   set   zset
     *
     * @param key  键
     * @return    值
     */
    Object  getAuto(final K key);

    /**
     * 通过键数组  查询多个值
     *
     * @param key  键  可变参数
     * @return   值
     */
    List<V> get(final K... key);


    /**
     * 读取缓存，可以是对象，根据正则表达式匹配
     *
     * @param regKey  键
     * @return        值
     */
    List<Object>  getByRegular(final K regKey);


    /**
     * 模糊查询缓存
     *
     * @param pattern  查询参数
     * @return   集合
     */
    List<Object>  getByPattern(final String  pattern);


    List<Object>  getMapByPattern(final String pattern);


    /**
     * 写入缓存  可以是对象
     *
     * @param key    键
     * @param value  值
     */
    void  set(final K key, V value);


    /**
     * 写入缓存  设置过期时间
     *
     * @param key        键
     * @param value      值
     * @param expireTime  过期时间
     */
    void set(final K key, V value,Long expireTime);


    /**
     * 设置指定缓存的过期时间
     *
     * @param key   缓存键
     * @param expireTime  过期时间
     * @return  设置结果
     */
    boolean  setExpireTime(K key,Long expireTime);


    /**
     * 获取缓存的数据类型
     *
     * @param key  键
     * @return   数据类型
     */
    DataType  getType(K key);

    /**
     * 删除map中的某个对象 或属性
     *
     * @param key   键
     * @param field  属性
     */
    void  removeMapField(K key,V... field);


    /**
     * 获取map
     *
     * @param key  键
     * @return     map
     */
    Map<K,V> getMap(K key);


    /**
     * 获取map的值数量
     *
     * @param key  键
     * @return    hash长度
     */
    Long getMapSize(K key);


    /**
     * 获取hash表中指定的属性值
     *
     * @param key   键
     * @param field  属性
     * @param <T>  值类型
     * @return    值
     */
    <T>T  getMapField(K key,K field);

    /**
     * 判断hash表中指定的属性是否存在
     *
     * @param key   键
     * @param field 属性
     * @return      boolean
     */
    boolean  hasMapKey(K key,K field);


    /**
     * 获取hash表value  所有属性值
     * @param key   键
     * @return      值
     */
    List<V>  getMapFieldValue(K key);


    /**
     * 获取hash表中对应的键
     *
     * @param key  键
     * @return     键集合
     */
    Set<V>  getMapFieldKey(K key);


    /**
     * 对hash表中的某个属性的值增加 前提是该属性值必须是数值类型
     *
     * @param key    键
     * @param field  属性
     * @param increment  增值
     * @return   增后的值
     */
    long  setMapIncrby(K key,K field,long increment);


    /**
     * 对hash表中某个属性增值 小数类型
     *
     * @param key      键
     * @param field    属性
     * @param increment  增值
     * @return  增加的值
     */
    double  setMapIncrbyFloat(K key,K field,double increment);


    /**
     * 默认添加缓存  不覆盖
     *
     * @param key    键
     * @param value  值  可以是任意类型
     */
    void  addAuto(K key,Object value);

    /**
     * 覆盖 比如hash  list   set中的值会直接删除重新添加
     * @param key    键
     * @param value 值
     */
    void  setAuto(K key,Object value);


    /**
     * 向hash表中添加新的字段值
     *
     * @param key   缓存键
     * @param field  hash键
     * @param value  值
     */
    void addMap(K key,K field,Object value);


    /**
     * hash表添加
     * @param key  键
     * @param map  hash
     */
    void  addMap(K key,Map<K,V> map);


    /**
     * 向hash表中添加新值，设置hash的过期时间
     *
     * @param key    键
     * @param field  hash键
     * @param value  值
     * @param time   过期时间
     */
    void  addMap(K key,K field, V value,long time);


    /**
     * 向set中加入对象
     *
     * @param key  键
     * @param obj  对象
     */
    void  addSet(K key,V... obj);

    void  addSet(K key,Set<V> obj);


    /**
     * 处理事务时，锁定键
     *
     * @param key 键
     */
    void  watch(String key);

    /**
     * 移除set集合中的值
     *
     * @param key   键
     * @param value  值
     * @return     移除值的数量
     */
    long removeSetValue(K key,V value);


    /**
     * 移除set集合中的值
     *
     * @param key   键
     * @param value  值
     * @return     移除值的数量
     */
    long removeSetValue(K key,V... value);


    /**
     * 获取set的集合数量
     *
     * @param key  键
     * @return  数量
     */
    long getSetSize(K key);


    /**
     * 判断set集合中是否存在指定值
     *
     * @param key   键
     * @param value  值
     * @return  是否存在boolean
     */
    boolean  hasSetValue(K key , V value);


    /**
     * 获取整个set集合
     *
     * @param key  键
     * @return  set集合
     */
    Set<V>  getSet(K key);


    /**
     * 获取set集合之间的并集
     *
     * @param key      键 可变参数
     * @return   并集
     */
    Set<V>  getSetUnion(K... key);


    /**
     * 获取并集
     * @param key  set键
     * @param set  set集合
     * @return   并集
     */
    Set<V>  getSetUnion(K key,Set<Object> set);


    /**
     * 获取交集
     *
     * @param key set键  可变参数
     * @return     交集
     */
    Set<V>  getIntersect(K... key);


    /**
     * 获取set交集
     *
     * @param key      键
     * @param set  其他的集合
     * @return   交集
     */
    Set<V>  getIntersect(K key,Set<Object> set);


    /**
     * 模糊移除 支持*号
     *
     * @param blears  模糊键
     */
    void  removeBlear(K... blears);


    /**
     * 更新名称，如果不存在或者更新不成功则返回false
     * @param oldKey 旧key
     * @param newKey 新key
     * @return    boolean
     */
    boolean  renameIfExist(String oldKey,String newKey);


    /**
     * 根据正则表达式移除缓存
     *
     * @param reg  reg
     */
    void  removeByRegular(String... reg);


    /**
     * 根据正则表达式移除hash表中的值
     *
     * @param key  键
     * @param reg  正则表达式
     */
    void  removeMapFieldByRegular(K key,K...reg);


    /**
     * 删除有序集合中指定的某些值
     *
     * @param key    缓存键
     * @param value   集合中指定的值，可变参数
     * @return      删除数量
     */
    Long removeZSetValue(K key,V... value);


    /**
     * 异常有序集合 通过键
     * @param key  键
     */
    void  removeZSet(K key);


    /**
     * 删除有序集合中指定 分数区间中的值
     *
     * @param key     键
     * @param start   删除的索引开始为止
     * @param end     删除的索引结束位置
     */
    void  removeZSetRange(K key,Long  start,Long end);

    /**
     * 将key 和 key1的集合并集去除，复制到key2集合中
     * @param key   键
     * @param key1  键1
     * @param key2  键2
     */
    void  setZSetUnionAndStore(String key,String key1,String key2);


    /**
     * 获取整个有序集合  正序
     *
     * @param key  键
     * @param <T>  值类型
     * @return     值
     */
    <T>T  getZSetRange(K key);


    /**
     * 获取指定索引区间中的有序集合，正序
     * @param key    键
     * @param start  索引开始
     * @param end    索引结束为止
     * @param <T>    返回类型
     * @return    返回值
     */
    <T>T  getZSetRange(K key,long start,long end);


    /**
     * 获取整个有序集合  倒序
     *
     * @param key  键
     * @return     集合
     */
    Set<Object>  getZSetReverseRange(K key);


    /**
     * 获取有序集合 指定区间内的值倒序
     * @param key     键
     * @param start   开始下标
     * @param end     结束小标
     * @return      集合
     */
    Set<V> getZSetReverseRange(K key,long start,long end);


    /**
     * 获取有序集合 根据指定分数区间  正序从小到大
     *
     * @param key    键
     * @param start  开始分数
     * @param end    结束分数
     * @return      集合
     */
    Set<V> getZSetRangeByScore(K key,double start,double end);


    /**
     * 获取有序集合，根据指定分数区间从大到小
     *
     * @param key  键
     * @param start  最低分数
     * @param end    最高分数
     * @return  集合
     */
    Set<V> getZSetReverseRangeByScore(K key,double start , double end);


    /**
     * 返回zset全部值(包含值以及分数)  正序根据索引区间
     *
     * @param key   键
     * @param start  开始下标
     * @param end    结束小标
     * @return    zset集合
     */
    Set<ZSetOperations.TypedTuple<V>>  getZSetRangeWithScore(K key,long start,long end);


    /**
     * 返回zset全部值  倒序
     * @param key      键
     * @param start    开始下标
     * @param end      结束下标
     * @return         zset集合
     */
    Set<ZSetOperations.TypedTuple<V>>  getZSetReverseRangeWithScore(K key,long start,long end);


    /**
     * 获取指定有序集合所有值  正序 包含值和分值
     * @param key   键
     * @return      集合
     */
    Set<ZSetOperations.TypedTuple<V>>  getZSetRangeWithScore(K key);


    /**
     * 获取指定有序集合所有值 倒序  包含值和分数
     * @param key  键
     * @return     集合
     */
    Set<ZSetOperations.TypedTuple<V>>  getZSetReverseRangeWithScore(K key);


    /**
     * 通过分值以及键获取有序集合的数量
     *
     * @param key   键
     * @param start  最低分数
     * @param size   最高分数
     * @return     数量
     */
    long  getZSetCountSize(K key,double start,double size);


    /**
     * 获取指定有序集合的size
     * @param key   键
     * @return   长度
     */
    long  getZSetSize(K key);


    /**
     * 获取有序集合中指定值的分数
     *
     * @param key    键
     * @param value  集合中的值
     * @return   分数
     */
    double getZSetScore(K key, V value);


    /**
     * 对有序集合中指定的值 的分数新增
     *
     * @param key    键
     * @param value  有序集合中的值
     * @param delta  分数增量
     * @return     增后的分数
     */
    double  incrementZSetScore(K key,V value,double delta);


    /**
     * 在有序集合中添加值  指定分数
     *
     * @param key      键
     * @param score   分数
     * @param value   值
     * @return    添加结果
     */
    Boolean   addZSet(K key,double score,Object value);


    /***
     * 添加有序集合
     *
     * @param key  键
     * @param value  有序集合
     * @return   添加结果  添加多少
     */
    Long addZSet(K key, TreeSet<V> value);


    /**
     * 添加有序集合
     *
     * @param key   键
     * @param score  分数数组
     * @param value  值数组
     * @return    添加多少个
     */
    Long  addZSet(K key,double[] score,Object[] value);





}



























